home *** CD-ROM | disk | FTP | other *** search
/ Die Speccy' 97 / Die Speccy' 97.iso / amiga_system / the_aminet / comm / bbs / wwbbs31_source.lha / WWBBS / RxSrc / filebase.c < prev    next >
C/C++ Source or Header  |  1995-03-30  |  21KB  |  793 lines
  1. #include <exec/types.h>
  2. #include <exec/exec.h>
  3. #include <libraries/wwbbs.h>
  4. #include <ctype.h>
  5. #include <math.h>
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9.  
  10. #include <proto/dos.h>
  11. #include <proto/exec.h>
  12. #include <proto/rexxsyslib.h>
  13. #include <proto/wwbbs.h>
  14.  
  15. #include "rx.h"
  16.  
  17. #include "filebase.h"
  18.  
  19. void FileBaseCommand(BYTE *id,UWORD cmd,BYTE *arg)
  20.     {
  21.         BOOL updatevars=TRUE;
  22.         switch(cmd)
  23.             {
  24.                 case FILE_InitGlobal:
  25.                     InitFileGlobal(id);
  26.                     break;
  27.                 case FILE_EditSearchPatterns:
  28.                     EditFileSearchPatterns(id);
  29.                     break;
  30.                 case FILE_JoinArea:
  31.                     JoinFileArea(id);
  32.                     break;
  33.                 case FILE_ChangeArea:
  34.                     ChangeFileArea(id);
  35.                     updatevars=FALSE;
  36.                     break;
  37.                 case FILE_ParentArea:
  38.                     ParentFileArea(id);
  39.                     updatevars=FALSE;
  40.                     break;
  41.                 case FILE_NextArea:
  42.                     NextFileArea(id);
  43.                     updatevars=FALSE;
  44.                     break;
  45.                 case FILE_PreviousArea:
  46.                     PreviousFileArea(id);
  47.                     updatevars=FALSE;
  48.                     break;
  49.                 case FILE_Next:
  50.                     NextFile(id);
  51.                     break;
  52.                 case FILE_Current:
  53.                     CurrentFile(id);
  54.                     break;
  55.                 case FILE_Previous:
  56.                     PreviousFile(id);
  57.                     break;
  58.                 case FILE_Jump:
  59.                     JumptoFile(id);
  60.                     break;
  61.                 case FILE_List:
  62.                     ListFiles(id);
  63.                     break;
  64.                 case FILE_SearchNext:
  65.                     SearchNext(id);
  66.                     break;
  67.                 case FILE_Catchup:
  68.                     CatchupFiles(id);
  69.                     break;
  70.                 case FILE_Upload:
  71.                     Upload(id);
  72.                     updatevars=FALSE;
  73.                     break;
  74.                 case FILE_Download:
  75.                     Download(id);
  76.                     break;
  77.                 case FILE_ClearTagList:
  78.                     ClearFileTagList(id);
  79.                     break;
  80.                 case FILE_EditTagList:
  81.                     EditFileTagList(id);
  82.                     break;
  83.                 case FILE_Tag:
  84.                     TagFile(id);
  85.                     break;
  86.                 case FILE_ViewArchive:
  87.                     ViewArchive(id);
  88.                     break;
  89.                 case FILE_ReadTextFile:
  90.                     ReadTextFile(id);
  91.                     break;
  92.                 case FILE_UploadFromDisk:
  93.                     UploadFromDisk(id);
  94.                     updatevars=FALSE;
  95.                     break;
  96.                 case FILE_Kill:
  97.                     KillFile(id);
  98.                     updatevars=FALSE;
  99.                     break;
  100.                 case FILE_Move:
  101.                     MoveFile(id);
  102.                     updatevars=FALSE;
  103.                     break;
  104.                 case FILE_EditDescription:
  105.                     EditFileDescription(id);
  106.                     break;
  107.                 case FILE_EditAreaDescription:
  108.                     {
  109.                         if(strlen(file_area))
  110.                             {
  111.                                 BYTE group[21],filename[256];
  112.                                 strcpy(group,"");
  113.                                 strcpy(filename,"");
  114.                                 if(GetConfigTags(CFGTAG_Path,file_path,CFGTAG_Name,file_area,FBTAG_Group,group,FBTAG_Directory,filename,TAG_END))
  115.                                     {
  116.                                         AddPart(filename,".description",255);
  117.                                         printf("~p\nEnter a description for the area `%s'.\n",file_fullpath);
  118.                                         RunEditor(filename);
  119.                                     }
  120.                             }
  121.                         else
  122.                             printf("~s\nPlease enter a file area first.\n");
  123.                     }
  124.                     break;
  125.             }
  126.         if(updatevars)
  127.             FileUpdateVars(id);
  128.     }
  129.  
  130. void InitFileGlobal(BYTE *id)
  131.     {
  132.         if(file_global)
  133.             {
  134.                 BYTE path[256],name[33];
  135.                 BYTE user[33];
  136.                 UBYTE accesslevel=0;
  137.                 BYTE accessrange[21];
  138.                 BYTE group[41];
  139.                 BOOL autojoin=FALSE;
  140.                 strcpy(path,"FileBases");
  141.                 strcpy(name,"");
  142.                 strcpy(accessrange,"");
  143.                 strcpy(group,"");
  144.                 strcpy(user,"");
  145.                 GetStatusTags(STTAG_Name,id,STTAG_UserName,user,TAG_END);
  146.                 if(strlen(user))
  147.                     {
  148.                         GetUserTags(USRTAG_Name,user,USRTAG_AccessLevel,&accesslevel,TAG_END);
  149.                         while(GetNextArea(path,name))
  150.                             {
  151.                                 if(GetConfigTags(CFGTAG_Path,path,CFGTAG_Name,name,FBTAG_AccessRange,accessrange,FBTAG_Group,group,FBTAG_AutoJoin,&autojoin,TAG_END))
  152.                                     {
  153.                                         if(IsRange(accessrange,accesslevel) && autojoin)
  154.                                             AddFileGlobal(file_global,group,0);
  155.                                     }
  156.                             }
  157.                     }
  158.             }
  159.     }
  160.  
  161. void EditFileSearchPatterns(BYTE *id)
  162.     {
  163.         char *template[]={
  164.             "[1] File:        ",
  165.             "[2] Description: ",
  166.             "[3] Uploader:    ",
  167.             "[4] Reset Patterns",
  168.             NULL
  169.         };
  170.         char s[256],*p;
  171.         int index;
  172.         BOOL kg=TRUE;
  173.         while(!panic && kg)
  174.             {
  175.                 printf("~o\n");
  176.                 index=0;
  177.                 strcpy(s,"");
  178.                 while(template[index])
  179.                     {
  180.                         if(WaitForChar(Input(),0))
  181.                             {
  182.                                 getchar();
  183.                                 break;
  184.                             }
  185.                         switch(index)
  186.                             {
  187.                                 case 0: p=(strlen(file_filepattern)) ? file_filepattern : "#?"; break;
  188.                                 case 1: p=(strlen(file_descriptionpattern)) ? file_descriptionpattern : "#?"; break;
  189.                                 case 2: p=(strlen(file_uploaderpattern)) ? file_uploaderpattern : "#?"; break;
  190.                                 case 3: p=""; break;
  191.                                 default: p=NULL; break;
  192.                             }
  193.                         if(p)
  194.                             {
  195.                                 if(strlen(s))
  196.                                     {
  197.                                         if(strlen(template[index])+strlen(p)>39)
  198.                                             sprintf(&s[strlen(s)]," %s%-*s...",template[index],36-strlen(template[index]),p);
  199.                                         else
  200.                                             sprintf(&s[strlen(s)]," %s%-*s",template[index],39-strlen(template[index]),p);
  201.                                         printf("%s\n",s);
  202.                                         strcpy(s,"");
  203.                                     }
  204.                                 else
  205.                                     {
  206.                                         if(strlen(template[index])+strlen(p)>39)
  207.                                             sprintf(s,"%s%-*s...",template[index],36-strlen(template[index]),p);
  208.                                         else
  209.                                             sprintf(s,"%s%-*s",template[index],39-strlen(template[index]),p);
  210.                                     }
  211.                             }
  212.                         index++;
  213.                     }
  214.                 if(strlen(s))
  215.                     printf("%s\n",s);
  216.                 printf("~p\nEdit File Search Patterns: ");
  217.                 if(GetLine(s,1,GLFLG_Digits))
  218.                     {
  219.                         index=atoi(s);
  220.                         switch(index)
  221.                             {
  222.                                 case 1:
  223.                                     printf("~p\nEnter an AmigaDOS style pattern for the file names.\n: ");
  224.                                     if(GetLine(s,40,NULL))
  225.                                         strcpy(file_filepattern,s);
  226.                                     else
  227.                                         strcpy(file_filepattern,"");
  228.                                     break;
  229.                                 case 2:
  230.                                     printf("~p\nEnter an AmigaDOS style pattern for the file descriptions.\n: ");
  231.                                     if(GetLine(s,40,NULL))
  232.                                         strcpy(file_descriptionpattern,s);
  233.                                     else
  234.                                         strcpy(file_descriptionpattern,"");
  235.                                     break;
  236.                                 case 3:
  237.                                     printf("~p\nEnter an AmigaDOS style pattern for the uploaders' names.\n: ");
  238.                                     if(GetLine(s,40,NULL))
  239.                                         strcpy(file_uploaderpattern,s);
  240.                                     else
  241.                                         strcpy(file_uploaderpattern,"");
  242.                                     break;
  243.                                 case 4:
  244.                                     strcpy(file_filepattern,"");
  245.                                     strcpy(file_descriptionpattern,"");
  246.                                     strcpy(file_uploaderpattern,"");
  247.                                     printf("~s\nFile search patterns reset.\n");
  248.                                     break;
  249.                             }
  250.                     }
  251.                 else
  252.                     kg=FALSE;
  253.             }
  254.     }
  255.  
  256. struct List *OpenFileGlobal(BYTE *id)
  257.     {
  258.         struct List *ret=NULL;
  259.         BYTE file[256],user[33];
  260.         strcpy(user,"");
  261.         GetStatusTags(STTAG_Name,id,STTAG_UserName,user,TAG_END);
  262.         if(strlen(user))
  263.             {
  264.                 if(ret=AllocVec(sizeof(struct List),MEMF_CLEAR))
  265.                     {
  266.                         NewList(ret);
  267.                         if(GetVar("HOME",file,255,NULL)!=-1)
  268.                             {
  269.                                 FILE *fp;
  270.                                 AddPart(file,".fileglobal",255);
  271.                                 if(fp=fopen(file,"r"))
  272.                                     {
  273.                                         BYTE buff[256];
  274.                                         struct FileGlobalNode *node;
  275.                                         while(fgets(buff,255,fp))
  276.                                             {
  277.                                                 if(node=AllocVec(sizeof(struct FileGlobalNode),MEMF_CLEAR))
  278.                                                     {
  279.                                                         sscanf(buff,"%s %ld",node->fgn_Name,&node->fgn_High);
  280.                                                         node->fgn_Node.ln_Name=node->fgn_Name;
  281.                                                         AddTail(ret,(struct Node *) node);
  282.                                                     }
  283.                                             }
  284.                                         fclose(fp);
  285.                                     }
  286.                             }
  287.                     }
  288.             }
  289.         return(ret);
  290.     }
  291.  
  292. void CloseFileGlobal(struct List *list)
  293.     {
  294.         BYTE file[256];
  295.         if(GetVar("HOME",file,255,NULL)!=-1)
  296.             {
  297.                 FILE *fp;
  298.                 AddPart(file,".fileglobal",255);
  299.                 if(fp=fopen(file,"w"))
  300.                     {
  301.                         struct FileGlobalNode *node;
  302.                         for(node=(struct FileGlobalNode *) list->lh_Head;node->fgn_Node.ln_Succ;node=(struct FileGlobalNode *) node->fgn_Node.ln_Succ)
  303.                             fprintf(fp,"%s %ld\n",node->fgn_Name,node->fgn_High);
  304.                         fclose(fp);
  305.                     }
  306.             }
  307.         {
  308.             struct FileGlobalNode *node;
  309.             while(node=(struct FileGlobalNode *) RemHead(list))
  310.                 FreeVec(node);
  311.             FreeVec(list);
  312.         }
  313.     }
  314.  
  315. BOOL AddFileGlobal(struct List *list,BYTE *name,ULONG high)
  316.     {
  317.         BOOL ret=FALSE;
  318.         struct FileGlobalNode *node;
  319.         if(node=AllocVec(sizeof(struct FileGlobalNode),MEMF_CLEAR))
  320.             {
  321.                 strcpy(node->fgn_Name,name);
  322.                 node->fgn_High=high;
  323.                 node->fgn_Node.ln_Name=node->fgn_Name;
  324.                 AddTail(list,(struct Node *) node);
  325.                 ret=TRUE;
  326.             }
  327.         return(ret);
  328.     }
  329.  
  330. BOOL DeleteFileGlobal(struct List *list,BYTE *name)
  331.     {
  332.         BOOL ret=FALSE;
  333.         struct FileGlobalNode *node;
  334.         if(node=(struct FileGlobalNode *) FindName(list,name))
  335.             {
  336.                 Remove((struct Node *) node);
  337.                 FreeVec(node);
  338.                 ret=TRUE;
  339.             }
  340.         return(ret);
  341.     }
  342.  
  343. ULONG GetFileGlobalHigh(struct List *list,BYTE *name)
  344.     {
  345.         ULONG ret=0;
  346.         struct FileGlobalNode *node;
  347.         if(node=(struct FileGlobalNode *) FindName(list,name))
  348.             ret=node->fgn_High;
  349.         return(ret);
  350.     }
  351.  
  352. BOOL SetFileGlobalHigh(struct List *list,BYTE *name,ULONG high)
  353.     {
  354.         BOOL ret=FALSE;
  355.         struct FileGlobalNode *node;
  356.         if(node=(struct FileGlobalNode *) FindName(list,name))
  357.             {
  358.                 node->fgn_High=high;
  359.                 ret=TRUE;
  360.             }
  361.         return(ret);
  362.     }
  363.  
  364. struct List *OpenFileTagList(BYTE *id)
  365.     {
  366.         struct List *ret=NULL;
  367.         BYTE file[256],user[33];
  368.         strcpy(user,"");
  369.         GetStatusTags(STTAG_Name,id,STTAG_UserName,user,TAG_END);
  370.         if(strlen(user))
  371.             {
  372.                 if(ret=AllocVec(sizeof(struct List),MEMF_CLEAR))
  373.                     {
  374.                         NewList(ret);
  375.                         if(GetVar("HOME",file,255,NULL)!=-1)
  376.                             {
  377.                                 FILE *fp;
  378.                                 AddPart(file,".filetaglist",255);
  379.                                 if(fp=fopen(file,"r"))
  380.                                     {
  381.                                         struct FileTagData data;
  382.                                         struct FileTagNode *node;
  383.                                         while(fread(&data,sizeof(struct FileTagData),1,fp))
  384.                                             {
  385.                                                 if(node=AllocVec(sizeof(struct FileTagNode),MEMF_CLEAR))
  386.                                                     {
  387.                                                         strcpy(node->ftn_Path,data.ftd_Path);
  388.                                                         strcpy(node->ftn_Area,data.ftd_Area);
  389.                                                         node->ftn_ID=data.ftd_ID;
  390.                                                         strcpy(node->ftn_Name,data.ftd_Name);
  391.                                                         node->ftn_Size=data.ftd_Size;
  392.                                                         node->ftn_Node.ln_Name=node->ftn_Name;
  393.                                                         AddTail(ret,(struct Node *) node);
  394.                                                     }
  395.                                             }
  396.                                         fclose(fp);
  397.                                     }
  398.                             }
  399.                     }
  400.             }
  401.         return(ret);
  402.     }
  403.  
  404. void CloseFileTagList(struct List *list)
  405.     {
  406.         BYTE file[256];
  407.         if(GetVar("HOME",file,255,NULL)!=-1)
  408.             {
  409.                 FILE *fp;
  410.                 AddPart(file,".filetaglist",255);
  411.                 if(fp=fopen(file,"w"))
  412.                     {
  413.                         struct FileTagNode *node;
  414.                         for(node=(struct FileTagNode *) list->lh_Head;node->ftn_Node.ln_Succ;node=(struct FileTagNode *) node->ftn_Node.ln_Succ)
  415.                             fwrite(node->ftn_Path,sizeof(struct FileTagData),1,fp);
  416.                         fclose(fp);
  417.                     }
  418.             }
  419.         {
  420.             struct Node *node;
  421.             while(node=RemHead(list))
  422.                 FreeVec(node);
  423.             FreeVec(list);
  424.         }
  425.     }
  426.  
  427. BOOL AddFileTag(struct List *list,BYTE *path,BYTE *area,ULONG id,BYTE *name,ULONG size)
  428.     {
  429.         BOOL ret=FALSE;
  430.         struct FileTagNode *node;
  431.         if(node=AllocVec(sizeof(struct FileTagNode),MEMF_CLEAR))
  432.             {
  433.                 strcpy(node->ftn_Path,path);
  434.                 strcpy(node->ftn_Area,area);
  435.                 node->ftn_ID=id;
  436.                 strcpy(node->ftn_Name,name);
  437.                 node->ftn_Size=size;
  438.                 node->ftn_Node.ln_Name=node->ftn_Name;
  439.                 AddTail(list,(struct Node *) node);
  440.                 ret=TRUE;
  441.             }
  442.         return(ret);
  443.     }
  444.  
  445. BOOL DeleteFileTag(struct List *list,BYTE *name)
  446.     {
  447.         BOOL ret=FALSE;
  448.         struct Node *node;
  449.         if(node=FindName(list,name))
  450.             {
  451.                 Remove(node);
  452.                 FreeVec(node);
  453.                 ret=TRUE;
  454.             }
  455.         return(ret);
  456.     }
  457.  
  458. BYTE *GetFileTagPath(struct List *list,BYTE *name)
  459.     {
  460.         BYTE *ret=NULL;
  461.         struct FileTagNode *node;
  462.         if(node=(struct FileTagNode *) FindName(list,name))
  463.             ret=node->ftn_Path;
  464.         return(ret);
  465.     }
  466.  
  467. BYTE *GetFileTagArea(struct List *list,BYTE *name)
  468.     {
  469.         BYTE *ret=NULL;
  470.         struct FileTagNode *node;
  471.         if(node=(struct FileTagNode *) FindName(list,name))
  472.             ret=node->ftn_Area;
  473.         return(ret);
  474.     }
  475.  
  476. ULONG GetFileTagID(struct List *list,BYTE *name)
  477.     {
  478.         ULONG ret=0;
  479.         struct FileTagNode *node;
  480.         if(node=(struct FileTagNode *) FindName(list,name))
  481.             ret=node->ftn_ID;
  482.         return(ret);
  483.     }
  484.  
  485. ULONG GetFileTagSize(struct List *list,BYTE *name)
  486.     {
  487.         ULONG ret=NULL;
  488.         struct FileTagNode *node;
  489.         if(node=(struct FileTagNode *) FindName(list,name))
  490.             ret=node->ftn_Size;
  491.         return(ret);
  492.     }
  493.  
  494. int SelectFileArea(BYTE *id,UBYTE accesslevel,BYTE *result)
  495.     {
  496.         int selected=0,count=0;
  497.         {
  498.             ULONG next=0;
  499.             BYTE accessrange[21];
  500.             strcpy(accessrange,"");
  501.             while(next=GetConfigTags(CFGTAG_Path,file_path,CFGTAG_Next,next,FBTAG_AccessRange,accessrange,TAG_END))
  502.                 {
  503.                     if(IsRange(accessrange,accesslevel))
  504.                         count++;
  505.                 }
  506.         }
  507.         if(count)
  508.             {
  509.                 {
  510.                     char s[256];
  511.                     int index=0;
  512.                     ULONG next=0;
  513.                     BYTE *name=NULL;
  514.                     BOOL child=FALSE;
  515.                     BYTE accessrange[21];
  516.                     strcpy(s,"");
  517.                     strcpy(accessrange,"");
  518.                     printf("~o\n");
  519.                     while(next=GetConfigTags(CFGTAG_Path,file_path,CFGTAG_Name,&name,CFGTAG_Next,next,CFGTAG_Child,&child,FBTAG_AccessRange,accessrange,TAG_END))
  520.                         {
  521.                             if(IsRange(accessrange,accesslevel))
  522.                                 {
  523.                                     index++;
  524.                                     if(strlen(s))
  525.                                         {
  526.                                             sprintf(&s[strlen(s)]," [%*d] %s%c%*s",(int) (log10((double) count)+1),index,name,(child) ? '/' : ' ',32-strlen(name),"");
  527.                                             printf("%s\n",s);
  528.                                             strcpy(s,"");
  529.                                         }
  530.                                     else
  531.                                         sprintf(s,"[%*d] %s%c%*s",(int) (log10((double) count)+1),index,name,(child) ? '/' : ' ',32-strlen(name),"");
  532.                                 }
  533.                         }
  534.                     if(strlen(s))
  535.                         printf("%s\n",s);
  536.                 }
  537.                 {
  538.                     BYTE s[256];
  539.                     printf("~p\nSelect File Area: ");
  540.                     if(GetLine(s,(UWORD) (log10((double) count)+1),GLFLG_Digits))
  541.                         {
  542.                             if(atoi(s)>=1 && atoi(s)<=count)
  543.                                 {
  544.                                     ULONG next=0;
  545.                                     int i=0;
  546.                                     BYTE *name=NULL;
  547.                                     BYTE accessrange[21];
  548.                                     strcpy(accessrange,"");
  549.                                     while(next=GetConfigTags(CFGTAG_Path,file_path,CFGTAG_Name,&name,CFGTAG_Next,next,FBTAG_AccessRange,accessrange,TAG_END))
  550.                                         {
  551.                                             if(IsRange(accessrange,accesslevel))
  552.                                                 {
  553.                                                     i++;
  554.                                                     if(atoi(s)==i)
  555.                                                         {
  556.                                                             selected=i;
  557.                                                             if(result)
  558.                                                                 strcpy(result,name);
  559.                                                         }
  560.                                                 }
  561.                                         }
  562.                                 }
  563.                         }
  564.                 }
  565.             }
  566.         else
  567.             printf("~s\nNo file areas exist.\n");
  568.         return(selected);
  569.     }
  570.  
  571. void GetFileDescriptions(BYTE *id)
  572.     {
  573.         BYTE user[33];
  574.         strcpy(user,"");
  575.         GetStatusTags(STTAG_Name,id,STTAG_UserName,user,TAG_END);
  576.         if(strlen(user))
  577.             {
  578.                 APTR group;
  579.                 if(group=OpenFileGroup(file_path,file_area,EXCLUSIVE_LOCK))
  580.                     {
  581.                         ULONG next=0;
  582.                         BYTE *name=NULL;
  583.                         BYTE *uploader=NULL;
  584.                         BYTE *description=NULL;
  585.                         while(next=GetNextFile(group,next))
  586.                             {
  587.                                 if(GetFileTags(group,FILTAG_ID,next,FILTAG_Name,&name,FILTAG_Uploader,&uploader,FILTAG_Description,&description,TAG_END))
  588.                                     {
  589.                                         if(!description)
  590.                                             {
  591.                                                 if(!stricmp(uploader,user))
  592.                                                     {
  593.                                                         BYTE file[128];
  594.                                                         sprintf(file,"T:%s.%s",name,id);
  595.                                                         printf("~s\nPlease enter a description for `%s'.\n",name);
  596.                                                         if(RunEditor(file))
  597.                                                             {
  598.                                                                 BYTE *buff=NULL;
  599.                                                                 {
  600.                                                                     BPTR fh;
  601.                                                                     if(fh=Open(file,MODE_OLDFILE))
  602.                                                                         {
  603.                                                                             __aligned struct FileInfoBlock fib;
  604.                                                                             if(ExamineFH(fh,&fib))
  605.                                                                                 {
  606.                                                                                     if(buff=AllocVec(fib.fib_Size+1,MEMF_CLEAR))
  607.                                                                                         {
  608.                                                                                             if(FRead(fh,buff,sizeof(BYTE),fib.fib_Size)==fib.fib_Size)
  609.                                                                                                 SetFileTags(group,FILTAG_ID,next,FILTAG_Description,buff,FILTAG_DontSave,TRUE,TAG_END);
  610.                                                                                             FreeVec(buff);
  611.                                                                                         }
  612.                                                                                 }
  613.                                                                             Close(fh);
  614.                                                                         }
  615.                                                                 }
  616.                                                                 DeleteFile(file);
  617.                                                             }
  618.                                                     }
  619.                                             }
  620.                                     }
  621.                             }
  622.                         SetFileTags(group,FILTAG_ForceSave,TRUE,TAG_END);
  623.                         CloseFileGroup(group);
  624.                     }
  625.             }
  626.     }
  627.  
  628. void ProcessLogFile(BYTE *id)
  629.     {
  630.         BYTE user[33];
  631.         strcpy(user,"");
  632.         GetStatusTags(STTAG_Name,id,STTAG_UserName,user,TAG_END);
  633.         if(strlen(user))
  634.             {
  635.                 UBYTE ratiofile=0,ratiobyte=0;
  636.                 ULONG filesupld,filesdnld,kilosupld,kilosdnld,creditsfile,creditskilo;
  637.                 if(GetUserTags(USRTAG_Name,user,
  638.                         USRTAG_RatioByte,&ratiobyte,USRTAG_RatioFile,&ratiofile,
  639.                         USRTAG_FilesUploaded,&filesupld,USRTAG_FilesDownloaded,&filesdnld,
  640.                         USRTAG_KilosUploaded,&kilosupld,USRTAG_KilosDownloaded,&kilosdnld,
  641.                         USRTAG_FilesCredits,&creditsfile,USRTAG_KilosCredits,&creditskilo,
  642.                         TAG_END))
  643.                     {
  644.                         FILE *fp;
  645.                         BYTE file[64];
  646.                         sprintf(file,"T:wwbbs_filelog.%s",id);
  647.                         if(fp=fopen(file,"r"))
  648.                             {
  649.                                 char result[256],action,filename[256],*p;
  650.                                 long bytes;
  651.                                 while(fgets(result,255,fp))
  652.                                     {
  653.                                         /* cut off last data item */
  654.                                         p=&result[strlen(result)-1];
  655.                                         while(*p!=' ')
  656.                                             p--;
  657.                                         while(*p==' ')
  658.                                             {
  659.                                                 *p=NULL;
  660.                                                 p--;
  661.                                             }
  662.                                         /* read line */
  663.                                         p=result;
  664.                                         action=*p;
  665.                                         p=strchr(p,' '); while(*p==' ') p++; /* bytes */
  666.                                         sscanf(p,"%ld",&bytes);
  667.                                         p=strchr(p,' '); while(*p==' ') p++; /* bps */
  668.                                         p=strchr(p,' '); while(*p==' ') p++; /* `bps' */
  669.                                         p=strchr(p,' '); while(*p==' ') p++; /* cps */
  670.                                         p=strchr(p,' '); while(*p==' ') p++; /* `cps' */
  671.                                         p=strchr(p,' '); while(*p==' ') p++; /* errors */
  672.                                         p=strchr(p,' '); while(*p==' ') p++; /* `errors' */
  673.                                         p=strchr(p,' '); while(*p==' ') p++; /* flow */
  674.                                         p=strchr(p,' '); while(*p==' ') p++; /* last */
  675.                                         p=strchr(p,' '); while(*p==' ') p++; /* fname */
  676.                                         strcpy(filename,p);
  677.                                         /* process */
  678.                                         switch(action)
  679.                                             {
  680.                                                 case 'H': /* file is sent */
  681.                                                     /* increment download count */
  682.                                                     {
  683.                                                         BYTE *path=NULL,*area=NULL;
  684.                                                         ULONG id=0;
  685.                                                         struct DateStamp ds;
  686.                                                         path=GetFileTagPath(file_taglist,filename);
  687.                                                         area=GetFileTagArea(file_taglist,filename);
  688.                                                         id=GetFileTagID(file_taglist,filename);
  689.                                                         DateStamp(&ds);
  690.                                                         if(path && area && id)
  691.                                                             {
  692.                                                                 APTR group;
  693.                                                                 if(group=OpenFileGroup(path,area,EXCLUSIVE_LOCK))
  694.                                                                     {
  695.                                                                         UWORD downloads=0;
  696.                                                                         if(GetFileTags(group,FILTAG_ID,id,FILTAG_Downloads,&downloads,TAG_END))
  697.                                                                             {
  698.                                                                                 downloads++;
  699.                                                                                 SetFileTags(group,FILTAG_ID,id,FILTAG_Downloads,downloads,FILTAG_LastDownloadDate,&ds,TAG_END);
  700.                                                                             }
  701.                                                                         CloseFileGroup(group);
  702.                                                                     }
  703.                                                             }
  704.                                                         else
  705.                                                             {
  706.                                                                 if(file_current)
  707.                                                                     {
  708.                                                                         APTR group;
  709.                                                                         if(group=OpenFileGroup(file_path,file_area,EXCLUSIVE_LOCK))
  710.                                                                             {
  711.                                                                                 UWORD downloads=0;
  712.                                                                                 if(GetFileTags(group,FILTAG_ID,file_current,FILTAG_Downloads,&downloads,TAG_END))
  713.                                                                                     {
  714.                                                                                         downloads++;
  715.                                                                                         SetFileTags(group,FILTAG_ID,file_current,FILTAG_Downloads,downloads,FILTAG_LastDownloadDate,&ds,TAG_END);
  716.                                                                                     }
  717.                                                                                 CloseFileGroup(group);
  718.                                                                             }
  719.                                                                     }
  720.                                                             }
  721.                                                     }
  722.                                                     /* remove from tag list */
  723.                                                     {
  724.                                                         struct Node *node;
  725.                                                         if(node=FindName(file_taglist,filename))
  726.                                                             {
  727.                                                                 Remove(node);
  728.                                                                 FreeVec(node);
  729.                                                             }
  730.                                                     }
  731.                                                     filesdnld++;
  732.                                                     kilosdnld+=bytes/1024;
  733.                                                     if(ratiofile)
  734.                                                         creditsfile--;
  735.                                                     if(ratiobyte)
  736.                                                         creditskilo-=bytes/1024;
  737.                                                     break;
  738.                                                 case 'R': /* file is received */
  739.                                                     {
  740.                                                         APTR group;
  741.                                                         if(group=OpenFileGroup(file_path,file_area,EXCLUSIVE_LOCK))
  742.                                                             {
  743.                                                                 ULONG num=0;
  744.                                                                 if(num=AddFileTags(group,FILTAG_DontSave,TRUE,TAG_END))
  745.                                                                     {
  746.                                                                         SetFileTags(group,
  747.                                                                             FILTAG_ID,num,
  748.                                                                             FILTAG_Name,FilePart(filename),
  749.                                                                             FILTAG_Uploader,user,
  750.                                                                             FILTAG_Size,bytes,
  751.                                                                             TAG_END);
  752.                                                                     }
  753.                                                                 file_promptlow=GetNextFile(group,0);
  754.                                                                 file_prompthigh=GetPreviousFile(group,~0);
  755.                                                                 CloseFileGroup(group);
  756.                                                             }
  757.                                                         filesupld++;
  758.                                                         kilosupld+=bytes/1024;
  759.                                                         if(ratiofile)
  760.                                                             creditsfile+=ratiofile;
  761.                                                         if(ratiobyte)
  762.                                                             creditskilo+=(bytes/1024)*ratiobyte;
  763.                                                     }
  764.                                                     break;
  765.                                             }
  766.                                     }
  767.                                 fclose(fp);
  768.                             }
  769.                         SetUserTags(USRTAG_Name,user,
  770.                             USRTAG_FilesUploaded,filesupld,USRTAG_FilesDownloaded,filesdnld,
  771.                             USRTAG_KilosUploaded,kilosupld,USRTAG_KilosDownloaded,kilosdnld,
  772.                             USRTAG_FilesCredits,creditsfile,USRTAG_KilosCredits,creditskilo,
  773.                             TAG_END);
  774.                     }
  775.             }
  776.     }
  777.  
  778. void FileUpdateVars(BYTE *id)
  779.     {
  780.         file_promptlow=0;
  781.         file_prompthigh=0;
  782.         if(strlen(file_area))
  783.             {
  784.                 APTR group;
  785.                 if(group=OpenFileGroup(file_path,file_area,SHARED_LOCK))
  786.                     {
  787.                         file_promptlow=GetNextFile(group,0);
  788.                         file_prompthigh=GetPreviousFile(group,~0);
  789.                         CloseFileGroup(group);
  790.                     }
  791.             }
  792.     }
  793.